// 2010年版权归Go作者所有。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

// go:构建aix | | |达尔文| | |蜻蜓| | freebsd | | linux | | netbsd | openbsd | plan9 | | solaris
// +构建aix达尔文蜻蜓freebsd linux netbsd openbsd plan9 solaris

// Unix加密安全伪随机数
// 发电机

package rand

import (
	"bufio"
	"crypto/aes"
	"crypto/cipher"
	"encoding/binary"
	"io"
	"os"
	"runtime"
	"sync"
	"sync/atomic"
	"time"
)

const urandomDevice = "/dev/urandom"

// 易于实现：从/dev/uradom读取。
// 这在Linux、OS X和FreeBSD上就足够了。

func init() {
	if runtime.GOOS == "plan9" {
		Reader = newReader(nil)
	} else {
		Reader = &devReader{name: urandomDevice}
	}
}

// devReader通过读取名为name的文件来满足读取。
type devReader struct {
	name string
	f    io.Reader
	mu   sync.Mutex
	used int32 // 原子的是否已使用此标题
}

// altGetRandom if non nil指定要获取的操作系统特定函数
// 乌兰多姆风格的随机性。
var altGetRandom func([]byte) (ok bool)

func warnBlocked() {
	println("crypto/rand: blocked for 60 seconds waiting to read random data from the kernel")
}

func (r *devReader) Read(b []byte) (n int, err error) {
	if atomic.CompareAndSwapInt32(&r.used, 0, 1) {
		// 首先使用随机性。启动计时器以发出警告
		// 由于熵不可用而被阻塞。
		t := time.AfterFunc(60*time.Second, warnBlocked)
		defer t.Stop()
	}
	if altGetRandom != nil && r.name == urandomDevice && altGetRandom(b) {
		return len(b), nil
	}
	r.mu.Lock()
	defer r.mu.Unlock()
	if r.f == nil {
		f, err := os.Open(r.name)
		if f == nil {
			return 0, err
		}
		if runtime.GOOS == "plan9" {
			r.f = f
		} else {
			r.f = bufio.NewReader(hideAgainReader{f})
		}
	}
	return r.f.Read(b)
}

var isEAGAIN func(error) bool // 由eagain设置。在unix系统上运行

// hideAgainReader屏蔽从/dev/uradom读取的EAGAIN。
// 见golang.org/issue/9205
type hideAgainReader struct {
	r io.Reader
}

func (hr hideAgainReader) Read(p []byte) (n int, err error) {
	n, err = hr.r.Read(p)
	if err != nil && isEAGAIN != nil && isEAGAIN(err) {
		err = nil
	}
	return
}

// 在上使用的备用伪随机实现
// 没有可靠的/dev/uradom的系统。

// newReader返回一个新的伪随机生成器
// 通过读取熵来播种。如果熵=nil，
// 生成器通过读取系统的
// 随机数生成器，通常为/dev/random。
// 返回的读取器上的Read方法始终返回
// 请求的全部金额，否则返回错误。
// None
// 生成器使用AES-128的X9.31算法，
// 每生成1 MB数据后重新播种。
func newReader(entropy io.Reader) io.Reader {
	if entropy == nil {
		entropy = &devReader{name: "/dev/random"}
	}
	return &reader{entropy: entropy}
}

type reader struct {
	mu                   sync.Mutex
	budget               int // 可以生成的字节数
	cipher               cipher.Block
	entropy              io.Reader
	time, seed, dst, key [aes.BlockSize]byte
}

func (r *reader) Read(b []byte) (n int, err error) {
	r.mu.Lock()
	defer r.mu.Unlock()
	n = len(b)

	for len(b) > 0 {
		if r.budget == 0 {
			_, err := io.ReadFull(r.entropy, r.seed[0:])
			if err != nil {
				return n - len(b), err
			}
			_, err = io.ReadFull(r.entropy, r.key[0:])
			if err != nil {
				return n - len(b), err
			}
			r.cipher, err = aes.NewCipher(r.key[0:])
			if err != nil {
				return n - len(b), err
			}
			r.budget = 1 << 20 // 生成1MB后重新设定种子
		}
		r.budget -= aes.BlockSize

		// ANSI X9.31（=X9.17）算法，但使用AES代替3DES。
		// None
		// 单块：
		// t=加密（时间）
		// dst=加密（t^seed）
		// 种子=加密（t^dst）
		ns := time.Now().UnixNano()
		binary.BigEndian.PutUint64(r.time[:], uint64(ns))
		r.cipher.Encrypt(r.time[0:], r.time[0:])
		for i := 0; i < aes.BlockSize; i++ {
			r.dst[i] = r.time[i] ^ r.seed[i]
		}
		r.cipher.Encrypt(r.dst[0:], r.dst[0:])
		for i := 0; i < aes.BlockSize; i++ {
			r.seed[i] = r.time[i] ^ r.dst[i]
		}
		r.cipher.Encrypt(r.seed[0:], r.seed[0:])

		m := copy(b, r.dst[0:])
		b = b[m:]
	}

	return n, nil
}
